.TH std::numeric_limits::digits10 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::numeric_limits::digits10 \- std::numeric_limits::digits10

.SH Synopsis
   static const int digits10;      \fI(until C++11)\fP
   static constexpr int digits10;  \fI(since C++11)\fP

   The value of std::numeric_limits<T>::digits10 is the number of base-10 digits that
   can be represented by the type T without change, that is, any number with this many
   significant decimal digits can be converted to a value of type T and back to decimal
   form, without change due to rounding or overflow. For base-radix types, it is the
   value of digits() (digits - 1 for floating-point types) multiplied by \\(\\small
   \\log_{10}{radix}\\)log
   10(radix) and rounded down.

.SH Standard specializations

   T                         value of std::numeric_limits<T>::digits10
   /* non-specialized */     0
   bool                      0
   char                      std::numeric_limits<char>::digits * std::log10\fB(2)\fP
   signed char               std::numeric_limits<signed char>::digits * std::log10\fB(2)\fP
   unsigned char             std::numeric_limits<unsigned char>::digits * std::log10\fB(2)\fP
   wchar_t                   std::numeric_limits<wchar_t>::digits * std::log10\fB(2)\fP
   char8_t \fI(since C++20)\fP     std::numeric_limits<char8_t>::digits * std::log10\fB(2)\fP
   char16_t \fI(since C++11)\fP    std::numeric_limits<char16_t>::digits * std::log10\fB(2)\fP
   char32_t \fI(since C++11)\fP    std::numeric_limits<char32_t>::digits * std::log10\fB(2)\fP
   short                     std::numeric_limits<short>::digits * std::log10\fB(2)\fP
   unsigned short            std::numeric_limits<unsigned short>::digits *
                             std::log10\fB(2)\fP
   int                       std::numeric_limits<int>::digits * std::log10\fB(2)\fP
   unsigned int              std::numeric_limits<unsigned int>::digits * std::log10\fB(2)\fP
   long                      std::numeric_limits<long>::digits * std::log10\fB(2)\fP
   unsigned long             std::numeric_limits<unsigned long>::digits * std::log10\fB(2)\fP
   long long \fI(since C++11)\fP   std::numeric_limits<long long>::digits * std::log10\fB(2)\fP
   unsigned long long (since std::numeric_limits<unsigned long long>::digits *
   C++11)                    std::log10\fB(2)\fP
   float                     FLT_DIG (6 for IEEE float)
   double                    DBL_DIG (15 for IEEE double)
   long double               LDBL_DIG (18 for 80-bit Intel long double; 33 for IEEE
                             quadruple)

.SH Example

   An 8-bit binary type can represent any two-digit decimal number exactly, but 3-digit
   decimal numbers 256..999 cannot be represented. The value of digits10 for an 8-bit
   type is 2 (8 * std::log10(2) is 2.41)

   The standard 32-bit IEEE 754 floating-point type has a 24 bit fractional part (23
   bits written, one implied), which may suggest that it can represent 7 digit decimals
   (24 * std::log10(2) is 7.22), but relative rounding errors are non-uniform and some
   floating-point values with 7 decimal digits do not survive conversion to 32-bit
   float and back: the smallest positive example is 8.589973e9, which becomes
   8.589974e9 after the roundtrip. These rounding errors cannot exceed one bit in the
   representation, and digits10 is calculated as (24 - 1) * std::log10(2), which is
   6.92. Rounding down results in the value 6.

   Likewise, the 16-digit string 9007199254740993 does not survive text->double->text
   roundtrip, becoming 9007199254740992: the 64-bit IEEE 754 type double guarantees
   this roundtrip only for 15 decimal digits.

.SH See also

   max_digits10     number of decimal digits necessary to differentiate all values of
   \fB[static]\fP \fI(C++11)\fP this type
                    \fI(public static member constant)\fP
   radix            the radix or integer base used by the representation of the given
   \fB[static]\fP         type
                    \fI(public static member constant)\fP
   digits           number of radix digits that can be represented without change
   \fB[static]\fP         \fI(public static member constant)\fP
   min_exponent     one more than the smallest negative power of the radix that is a
   \fB[static]\fP         valid normalized floating-point value
                    \fI(public static member constant)\fP
   max_exponent     one more than the largest integer power of the radix that is a
   \fB[static]\fP         valid finite floating-point value
                    \fI(public static member constant)\fP
